use std::ops::{Deref, DerefMut};

#[derive(Debug)]
struct Buffer<T>(Vec<T>);

// 为任一传递给Buffer的结构实现了new方法
impl<T> Buffer<T> {
    pub fn new(v: impl Into<Vec<T>>) -> Self {
        // v约束为实现了可以转化为Vec的类型
        Self(v.into())
    }
}

// 为了让Buffer可以像slice切片那样使用,直接调用len(),first()等方法而不用获取到内部的Vec<T>
// 可以为Buffer实现Deref与DerefMut的trait
// 让调用过程中可以不刻意注意引用与值的使用,在传递值但是需要引用为参数的时候,会自动将值解引用
// 就可以使用引用内部类型的方法

impl<T> Deref for Buffer<T> {
    type Target = [T];
    //Self 和 self。
    // Self 代表当前的类型，比如 File 类型实现了 Write，
    // 那么实现过程中使用到的 Self 就指代 File。
    // self 在用作方法的第一个参数时，实际上是 self: Self 的简写，
    // 所以 &self 是 self: &Self, 而 &mut self 是 self: &mut Self。

    // 为什么使用[T]而不是Vec<T>
    // 切片是对数组或者Vec<T>的引用，它可以引用数组或者Vec<T>的一部分或者全部。
    // 因此，当在Buffer<T>实例上调用切片的方法时，
    // 可以操作Buffer<T>内部的Vec<T>的任何部分，而不仅仅是整个Vec<T>。

    fn deref(&self) -> &Self::Target {
        // 直接使用.0
        // 因为如果buffer要使用vec的方法,需要不断得到内部的vec再调用
        // 这里实现了Deref，直接返回了.0的情况，直接剩下许多啰嗦的步骤
        &self.0
    }
}

impl<T> DerefMut for Buffer<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

fn main() {
    let mut buf = Buffer::new([1, 3, 2, 4]);
    // 因为实现了 Deref 和 DerefMut，这里 buf 可以直接访问 Vec<T> 的方法
    // 下面这句相当于：(&mut buf).deref_mut().sort()，也就是 (&mut buf.0).sort()
    buf.sort();
    println!("buf: {:?}", buf);
}

/*
 buf.sort() 的时候，并没有做解引用的操作，
为什么会相当于访问了 buf.0.sort() 呢？
这是因为 sort() 方法第一个参数是 &mut self，
此时 Rust 编译器会强制做 Deref/DerefMut 的解引用，所以这相当于 (*(&mut buf)).sort()。
*/

// Rc的Deref
// impl<T: ?Sized> Deref for Rc<T> {
//     type Target = T;
//     fn deref(&self) -> &T {
//         &self.inner().value
//     }
// }
